home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 8 / QRZ Ham Radio Callsign Database - Volume 8.iso / mac / files / t_sys5 / unixcpio.gz / unixnet.cpio / session.c < prev    next >
C/C++ Source or Header  |  1994-07-11  |  9KB  |  449 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "iface.h"
  12. #include "ftp.h"
  13. #include "telnet.h"
  14. #ifdef _FINGER
  15. #include "finger.h"
  16. #endif
  17. #ifdef NETROM
  18. #include "netrom.h"
  19. #include "nr4.h"
  20. #endif
  21. #include "session.h"
  22. #include "cmdparse.h"
  23. #ifdef    UNIX
  24. #include <string.h>
  25. #endif
  26.  
  27. struct session *sessions;
  28. struct session *current;
  29. char notval[] = "Not a valid control block\n";
  30. char badsess[] = "Invalid session\n";
  31.  
  32. /* Convert a character string containing a decimal session index number 
  33.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  34.  * If the index is out of range or unused, return NULLSESSION.
  35.  */
  36. static struct session *
  37. sessptr(cp)
  38. char *cp;
  39. {
  40.     register struct session *s;
  41.     unsigned int i;
  42.  
  43.     if(cp == NULLCHAR){
  44.         s = current;
  45.     } else {
  46.         if((i = atoi(cp)) >= nsessions)
  47.             return NULLSESSION;
  48.         s = &sessions[i];
  49.     }
  50.     if(s == NULLSESSION || s->type == FREE)
  51.         return NULLSESSION;
  52.  
  53.     return s;
  54. }
  55.  
  56. /* Select and display sessions */
  57. dosession(argc,argv)
  58. int argc;
  59. char *argv[];
  60. {
  61.     struct session *s;
  62.     extern char *tcpstates[];
  63.     char *psocket();
  64.     extern char *ax25states[];
  65.     char *tcp_port();
  66.  
  67.     if(argc > 1){
  68.         if((current = sessptr(argv[1])) != NULLSESSION)
  69.             go();
  70.         return 0;
  71.     }
  72.     printf(" #       &CB Type   Rcv-Q  State        Remote socket\n");
  73.     for(s=sessions; s < &sessions[nsessions];s++){
  74.         switch(s->type){
  75.         case TELNET:
  76.             printf("%c%-3d%8lx Telnet  %4d  %-13s%-s:%s",
  77.              (current == s)? '*':' ',
  78.              (int)(s - sessions),
  79.              (long)s->cb.telnet->tcb,
  80.              s->cb.telnet->tcb->rcvcnt,
  81.              tcpstates[s->cb.telnet->tcb->state],
  82.              s->name,
  83.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  84.             break;
  85.         case FTP:
  86.             printf("%c%-3d%8lx FTP     %4d  %-13s%-s:%s",
  87.              (current == s)? '*':' ',
  88.              (int)(s - sessions),
  89.              (long)s->cb.ftp->control,
  90.              s->cb.ftp->control->rcvcnt,
  91.              tcpstates[s->cb.ftp->control->state],
  92.              s->name,
  93.              tcp_port(s->cb.ftp->control->conn.remote.port));
  94.             break;
  95. #ifdef    AX25
  96.         case AX25TNC:
  97.             printf("%c%-3d%8lx AX25    %4d  %-13s%-s",
  98.              (current == s)? '*':' ',
  99.              (int)(s - sessions),
  100.              (long)s->cb.ax25_cb,
  101.             len_mbuf(s->cb.ax25_cb->rxq),
  102.              ax25states[s->cb.ax25_cb->state],
  103.              s->name);
  104.             break;
  105. #endif
  106. #ifdef    _FINGER
  107.         case FINGER:
  108.             printf("%c%-3d%8lx Finger  %4d  %-13s%-s",
  109.              (current == s)? '*':' ',
  110.              (int)(s - sessions),
  111.              (long)s->cb.finger->tcb,
  112.              s->cb.finger->tcb->rcvcnt,
  113.              tcpstates[s->cb.finger->tcb->state],
  114.              s->name, s->cb.finger->tcb->conn.remote.port);
  115.             break;
  116. #endif
  117. #ifdef NETROM
  118.         case NRSESSION:
  119.             printf("%c%-3d%8lx NET/ROM %4d  %-13s%-s",
  120.              (current == s)? '*':' ',
  121.              (int)(s - sessions),
  122.              (long)s->cb.nr4_cb,
  123.             len_mbuf(s->cb.nr4_cb->rxq),
  124.              Nr4states[s->cb.nr4_cb->state],
  125.              s->name);
  126.             break;
  127. #endif
  128.         default:
  129.             continue;
  130.         }
  131.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  132.             printf("\t");
  133.         if(s->rfile != NULLCHAR)
  134.             printf("Record: %s ",s->rfile);
  135.         if(s->ufile != NULLCHAR)
  136.             printf("Upload: %s",s->ufile);
  137.         printf("\n");
  138.     }
  139.     return 0;
  140. }
  141. /* Enter conversational mode with current session */
  142. int
  143. go()
  144. {
  145.     void rcv_char(),ftpccr(),ax_rx(),fingcli_rcv() ;
  146.  
  147.     if(current == NULLSESSION || current->type == FREE)
  148.         return 0;
  149.     mode = CONV_MODE;
  150.     switch(current->type){
  151.     case TELNET:
  152.         if(current->cb.telnet->remote[TN_ECHO])
  153.             raw();    /* Re-establish raw mode if it was set */
  154.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  155.         break;
  156.     case FTP:
  157.         ftpccr(current->cb.ftp->control,0);
  158.         break;
  159. #ifdef    AX25
  160.     case AX25TNC:
  161.         ax_rx(current->cb.ax25_cb,0);
  162.         break;
  163. #endif
  164. #ifdef _FINGER
  165.     case FINGER:
  166.         fingcli_rcv(current->cb.finger->tcb,0) ;
  167.         break ;
  168. #endif
  169. #ifdef    NETROM
  170.     case NRSESSION:
  171.         nr4_rx(current->cb.nr4_cb,0) ;
  172.         break ;
  173. #endif
  174.     }
  175.     return 0;
  176. }
  177. doclose(argc,argv)
  178. int argc;
  179. char *argv[];
  180. {
  181.     struct session *s;
  182.  
  183.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  184.         printf(badsess);
  185.         return -1;
  186.     }
  187.     switch(s->type){
  188.     case TELNET:
  189.         close_tcp(s->cb.telnet->tcb);
  190.         break;
  191.     case FTP:
  192.         close_tcp(s->cb.ftp->control);
  193.         break;
  194. #ifdef    AX25
  195.     case AX25TNC:
  196.         disc_ax25(s->cb.ax25_cb);
  197.         break;
  198. #endif
  199. #ifdef _FINGER
  200.     case FINGER:
  201.         close_tcp(s->cb.finger->tcb);
  202.         break;
  203. #endif
  204. #ifdef NETROM
  205.     case NRSESSION:
  206.         disc_nr4(s->cb.nr4_cb) ;
  207.         break ;
  208. #endif
  209.     }
  210.     return 0;
  211. }
  212. doreset(argc,argv)
  213. int argc;
  214. char *argv[];
  215. {
  216.     long htol();
  217.     struct session *s;
  218.  
  219.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  220.         printf(badsess);
  221.         return -1;
  222.     }
  223.     switch(s->type){
  224.     case TELNET:
  225.         reset_tcp(s->cb.telnet->tcb);
  226.         break;
  227.     case FTP:
  228.         if(s->cb.ftp->data != NULLTCB){
  229.             reset_tcp(s->cb.ftp->data);
  230.             s->cb.ftp->data = NULLTCB;
  231.         }
  232.         reset_tcp(s->cb.ftp->control);
  233.         break;
  234. #ifdef    AX25
  235.     case AX25TNC:
  236.         reset_ax25(s->cb.ax25_cb);
  237.         break;
  238. #endif
  239. #ifdef _FINGER
  240.     case FINGER:
  241.         reset_tcp(s->cb.finger->tcb);
  242.         break;
  243. #endif
  244. #ifdef NETROM
  245.     case NRSESSION:
  246.         reset_nr4(s->cb.nr4_cb) ;
  247.         break ;
  248. #endif
  249.     }
  250.     return 0;
  251. }
  252. int
  253. dokick(argc,argv)
  254. int argc;
  255. char *argv[];
  256. {
  257.     long htol();
  258.     void tcp_timeout();
  259.     struct session *s;
  260.  
  261.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  262.         printf(badsess);
  263.         return -1;
  264.     }
  265.     switch(s->type){
  266.     case TELNET:
  267.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  268.             printf(notval);
  269.             return 1;
  270.         }
  271.         break;
  272.     case FTP:
  273.         if(kick_tcp(s->cb.ftp->control) == -1){
  274.  
  275.             printf(notval);
  276.             return 1;
  277.         }
  278.         if(s->cb.ftp->data != NULLTCB)
  279.             kick_tcp(s->cb.ftp->data);
  280.         break;
  281. #ifdef    AX25
  282.     case AX25TNC:
  283.         if(kick_ax25(s->cb.ax25_cb) == -1){
  284.             printf(notval);
  285.             return 1;
  286.         }
  287.         return 1;
  288. #endif
  289. #ifdef _FINGER
  290.     case FINGER:
  291.         if(kick_tcp(s->cb.finger->tcb) == -1){
  292.             printf(notval);
  293.             return 1;
  294.         }
  295.         break;
  296. #endif
  297. #ifdef NETROM
  298.     case NRSESSION:
  299.         if(kick_nr4(s->cb.nr4_cb) == -1) {
  300.             printf(notval) ;
  301.             return 1 ;
  302.         }
  303.         break ;
  304. #endif
  305.     }
  306.     return 0;
  307. }
  308. struct session *
  309. newsession()
  310. {
  311.     register int i;
  312.  
  313.     for(i=0;i<nsessions;i++)
  314.         if(sessions[i].type == FREE)
  315.             return &sessions[i];
  316.     return NULLSESSION;
  317. }
  318. freesession(s)
  319. struct session *s;
  320. {
  321.     if(s == NULLSESSION)
  322.         return;
  323.     if(s->record != NULLFILE){
  324.         fclose(s->record);
  325.         s->record = NULLFILE;
  326.     }
  327.     if(s->rfile != NULLCHAR){
  328.         free(s->rfile);
  329.         s->rfile = NULLCHAR;
  330.     }
  331.     if(s->upload != NULLFILE){
  332.         fclose(s->upload);
  333.         s->upload = NULLFILE;
  334.     }
  335.     if(s->ufile != NULLCHAR){
  336.         free(s->ufile);
  337.         s->ufile = NULLCHAR;
  338.     }
  339.     if(s->name != NULLCHAR){
  340.         free(s->name);
  341.         s->name = NULLCHAR;
  342.     }
  343.     s->type = FREE;
  344. }
  345. /* Control session recording */
  346. dorecord(argc,argv)
  347. int argc;
  348. char *argv[];
  349. {
  350.     if(current == NULLSESSION){
  351.         printf("No current session\n");
  352.         return 1;
  353.     }
  354.     if(argc > 1){
  355.         if(current->rfile != NULLCHAR){
  356.             fclose(current->record);
  357.             free(current->rfile);
  358.             current->record = NULLFILE;
  359.             current->rfile = NULLCHAR;
  360.         }
  361.         /* Open new record file, unless file name is "off", which means
  362.          * disable recording
  363.          */
  364.         if(strcmp(argv[1],"off") != 0
  365.          && (current->record = fopen(argv[1],"a")) != NULLFILE){
  366.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  367.             strcpy(current->rfile,argv[1]);
  368.         }
  369.     }
  370.     if(current->rfile != NULLCHAR)
  371.         printf("Recording into %s\n",current->rfile);
  372.     else
  373.         printf("Recording off\n");
  374.     return 0;
  375. }
  376. /* Control file transmission */
  377. doupload(argc,argv)
  378. int argc;
  379. char *argv[];
  380. {
  381.     struct tcb *tcb;
  382.     struct ax25_cb *axp;
  383. #ifdef NETROM
  384.     struct nr4cb *cb ;
  385. #endif
  386.  
  387.     if(current == NULLSESSION){
  388.         printf("No current session\n");
  389.         return 1;
  390.     }
  391.     if(argc > 1){
  392.         switch(current->type){
  393.         case TELNET:
  394.             tcb = current->cb.telnet->tcb;
  395.             break;
  396. #ifdef    AX25
  397.         case AX25TNC:
  398.             axp = current->cb.ax25_cb;
  399.             break;
  400. #endif
  401. #ifdef NETROM
  402.         case NRSESSION:
  403.             cb = current->cb.nr4_cb ;
  404.             break ;
  405. #endif
  406.         case FTP:
  407.             printf("Uploading on FTP control channel not supported\n");
  408.             return 1;
  409.         }
  410.         if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  411.             /* Abort upload */
  412.             fclose(current->upload);
  413.             current->upload = NULLFILE;
  414.             if(current->ufile != NULLCHAR){
  415.                 free(current->ufile);
  416.                 current->ufile = NULLCHAR;
  417.             }
  418.         }
  419.         /* Open upload file */
  420.         if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  421.             printf("Can't read %s\n",argv[1]);
  422.             return 1;
  423.         }
  424.         current->ufile = malloc((unsigned)strlen(argv[1])+1);
  425.         strcpy(current->ufile,argv[1]);
  426.         /* All set, kick transmit upcall to get things rolling */
  427.         switch(current->type){
  428. #ifdef    AX25
  429.         case AX25TNC:
  430.             (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  431.             break;
  432. #endif
  433. #ifdef NETROM
  434.         case NRSESSION:
  435.             (*cb->t_upcall)(cb, NR4MAXINFO) ;
  436.             break ;
  437. #endif
  438.         case TELNET:
  439.             (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  440.             break;
  441.         }
  442.     }
  443.     if(current->ufile != NULLCHAR)
  444.         printf("Uploading %s\n",current->ufile);
  445.     else
  446.         printf("Uploading off\n");
  447.     return 0;
  448. }
  449.